Transformation Techniques for OCL Constraints

Constraints play a key role in the definition of conceptual schemas. In the UML, constraints are usually specified by means of invariants written in the OCL. However, due to the high expressiveness of the OCL, the designer has different syntactic alternatives to express each constraint. The techniques presented in this paper assist the designer during the definition of the constraints by means of generating equivalent alternatives for the initially defined ones. Moreover, in the context of the MDA, transformations between these different alternatives are required as part of the PIM-to-PIM, PIM-to-PSM or PIM-to-code transformations of the original conceptual schema

Lightweight and static verification of UML executable models

Executable models play a key role in many software development methods by facilitating the (semi)automatic implementation/execution of the software system under development. This is possible because executable models promote a complete and fine-grained specification of the system behaviour. In this context, where models are the basis of the whole development process, the quality of the models has a high impact on the final quality of software systems derived from them. Therefore, the existence of methods to verify the correctness of executable models is crucial. Otherwise, the quality of the executable models (and in turn the quality of the final system generated from them) will be compromised. In this paper a lightweight and static verification method to assess the correctness of executable models is proposed. This method allows us to check whether the operations defined as part of the behavioural model are able to be executed without breaking the integrity of the structural model and returns a meaningful feedback that helps repairing the detected inconsistencies.Peer ReviewedPostprint (author's final draft

Discovering Implicit Schemas in JSON Data

International audienceJSON has become a very popular lightweigth format for data exchange. JSON is human readable and easy for computers to parse and use. However, JSON is schemaless. Though this brings some benefits (e.g., flexibility in the representation of the data) it can become a problem when consuming and integrating data from different JSON services since developers need to be aware of the structure of the schemaless data. We believe that a mechanism to discover (and visualize) the implicit schema of the JSON data would largely facilitate the creation and usage of JSON services. For instance, this would help developers to understand the links between a set of services belonging to the same domain or API. In this sense, we propose a model-based approach to generate the underlying schema of a set of JSON documents

Community-Driven Language Development

International audienceSoftware development processes are becoming more collaborative, trying to integrate end-users as much as possible. The idea is to advance towards a community- driven process where all actors (both technical and non-technical) work together to ensure that the system-to-be will satisfy all expectations. This seems specially appropriate in the field of Domain-Specific Languages (DSLs) typically designed to facilitate the development of software for a particular domain. DSLs offer constructs closer to the vocabulary of the domain which simplifies the adoption of the DSL by end-users. Interestingly enough, the development of DSLs is not a collaborative process itself. In this sense, the goal of this paper is to propose a collaborative infrastructure for the development of DSLs where end-users have a direct and active participation in the evolution of the language. This infrastructure is based on Collaboro, a DSL to represent change proposals, possible solutions and comments arisen during the development and evolution of a language

On Developing Open Source MDE Tools: Our Eclipse Stories and Lessons Learned

International audienceTool development has always been a fundamental activity of Software Engineering. Nowadays, open source is changing the way this is done in many organizations. Traditional ways of doing things are progressively enhanced or even sometimes replaced by new organizational schemes, benefiting as much as possible from the properties of open source (OS). This is especially true in innovative areas such as Model Driven Engineering (MDE) in which new tools are constantly created, developed and disseminated, many of them coming from research teams. This poses some hard questions: What is the actual impact of OS in terms of tool development? How to best take advantage of OS communities? And what are the opportunities for research teams in this context? Capitalizing on experiences in developing MDE OS tools on top of the Eclipse platform and its license model, we try to give some insights on these questions in this paper

Verifying UML/OCL operation contracts

In current model-driven development approaches, software models are the primary artifacts of the development process. Therefore, assessment of their correctness is a key issue to ensure the quality of the final application. Research on model consistency has focused mostly on the models' static aspects. Instead, this paper addresses the verification of their dynamic aspects, expressed as a set of operations defined by means of pre/postcondition contracts. This paper presents an automatic method based on Constraint Programming to verify UML models extended with OCL constraints and operation contracts. In our approach, both static and dynamic aspects are translated into a Constraint Satisfaction Problem. Then, compliance of the operations with respect to several correctness properties such as operation executability or determinism are formally verified

Els adroguers i sucrers de Barcelona 1700-1820. Un exemple d'élite gremial

-

Creación Colaborativa de Lenguajes Específicos del Dominio

National audienceEl desarrollo de sofware es un proceso donde participan muchos actores, principalmente los desarrolladores y los clientes del producto. En la actualidad, procesos de desarrollo como los basados en metodologías ágiles proponen la participación de forma directa de los usuarios o clientes. La idea clave es definir procesos guiados por la comunidad donde todos los participantes (técnicos y no técnicos) colaboran para que el producto satisfaga los requisitos. Esta aproximación es especialmente interesante en el ámbito del desarrollo de lenguajes específicos de dominio (DSL). Sin embargo, aunque estos lenguajes están destinados a una comunidad de usuarios expertos de un dominio concreto, actualmente dichos usuarios tienen poca (o nula) participación en el desarrollo. Nuestra propuesta consiste en incorporar el aspecto colaborativo en los procesos de desarrollo de DSLs, permitiendo a la comunidad de usuarios del lenguaje participar activamente en su creación y evolución. Para ello proponemos adaptar Collaboro, un lenguaje para representar las actividades de colaboración que surgen durante el desarrollo de DSLs, para ser utilizado a lo largo de todo el proceso